/**
 * API服务
 * 负责与DeepSeek或其他后端API的通信
 */

// API基础URL - 可以根据环境变量配置不同环境
const API_URL = import.meta.env.VITE_API_URL || 'https://api.deepseek.com';
// API超时设置 (毫秒) - 30秒超时
const API_TIMEOUT = 30000;
// 重试次数 - 最多重试2次
const MAX_RETRIES = 2;
// 默认模型
const DEFAULT_MODEL = import.meta.env.VITE_API_MODEL || "deepseek-reasoner";

/**
 * 发送聊天消息到API
 * @param {string} message - 用户输入的消息
 * @param {Array} history - 可选的聊天历史记录
 * @returns {Promise} - 返回API响应Promise
 * 
 * 功能说明:
 * 1. 发送消息到DeepSeek API并获取完整响应
 * 2. 包含错误处理和重试机制
 * 3. 实现请求超时控制
 */
export const sendMessage = async (message, history = []) => {
  let retries = 0;
  
  while (retries <= MAX_RETRIES) {
    try {
      // 设置请求超时控制
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT);
      
      // 发送API请求
      const response = await fetch(`${API_URL}/v1/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${import.meta.env.VITE_API_KEY || ''}`,
        },
        body: JSON.stringify({
          model: DEFAULT_MODEL,
          messages: [
            ...formatChatHistory(history),
            { role: "user", content: message }
          ],
          temperature: 0.7,      // 控制回答的随机性，值越大回答越多样化
          max_tokens: 2000,      // 回答的最大token数量
        }),
        signal: controller.signal // 用于请求中断
      });
      
      // 清除超时定时器
      clearTimeout(timeoutId);
      
      // 处理API错误响应
      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(errorData.message || `API响应错误: ${response.status}`);
      }

      // 返回完整的JSON响应
      return await response.json();
    } catch (error) {
      // 处理请求超时
      if (error.name === 'AbortError') {
        throw new Error('请求超时，请稍后重试');
      }
      
      // 处理重试逻辑
      retries++;
      if (retries > MAX_RETRIES) {
        console.error('API调用失败，已达到最大重试次数:', error);
        throw error;
      }
      
      // 指数退避重试 - 每次重试等待时间翻倍
      console.log(`API调用失败，正在进行第${retries}次重试...`);
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, retries - 1)));
    }
  }
};

/**
 * 格式化聊天历史以符合API要求
 * @param {Array} messages - 消息历史记录
 * @returns {Array} - 格式化后的消息数组
 * 
 * 将内部消息格式转换为DeepSeek API所需的格式
 */
const formatChatHistory = (messages) => {
  return messages.map(msg => ({
    role: msg.isUser ? "user" : "assistant",  // 角色：用户或助手
    content: msg.text                         // 消息内容
  }));
};

/**
 * 进行流式API调用
 * @param {string} message - 用户消息
 * @param {Array} history - 历史消息
 * @param {Function} onChunk - 处理每个数据块的回调
 * 
 * 功能说明:
 * 1. 发送消息到DeepSeek API并获取流式响应
 * 2. 实时处理返回的数据块
 * 3. 包含错误处理、超时控制和重试机制
 */
export const streamMessage = async (message, history = [], onChunk) => {
  let retries = 0;
  
  while (retries <= MAX_RETRIES) {
    try {
      // 设置请求超时控制
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT);
      
      // 发送API流式请求
      const response = await fetch(`${API_URL}/v1/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${import.meta.env.VITE_API_KEY || ''}`,
        },
        body: JSON.stringify({
          model: DEFAULT_MODEL,
          messages: [
            ...formatChatHistory(history),
            { role: "user", content: message }
          ],
          temperature: 0.7,
          max_tokens: 2000,
          stream: true,           // 启用流式响应
        }),
        signal: controller.signal
      });
      
      // 清除超时定时器
      clearTimeout(timeoutId);
      
      // 处理API错误响应
      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(errorData.message || `API响应错误: ${response.status}`);
      }

      // 处理流式响应
      const reader = response.body.getReader();
      const decoder = new TextDecoder("utf-8");
      let buffer = '';               // 用于存储未处理完的数据
      let lastActivityTime = Date.now(); // 记录最后活动时间，用于检测流超时
      
      while (true) {
        // 检查非活动超时 - 避免流式响应卡住
        if (Date.now() - lastActivityTime > API_TIMEOUT) {
          throw new Error('响应流超时');
        }
        
        // 读取数据块
        const { done, value } = await reader.read();
        if (done) break;
        
        // 更新最后活动时间
        lastActivityTime = Date.now(); 
        buffer += decoder.decode(value, { stream: true });
        
        // 处理缓冲区中的每一行数据
        const lines = buffer.split('\n');
        buffer = lines.pop() || ''; // 保留最后一个可能不完整的行
        
        // 处理每一行数据
        for (const line of lines) {
          // 处理数据行
          if (line.startsWith('data: ') && line !== 'data: [DONE]') {
            try {
              // 解析JSON数据
              const data = JSON.parse(line.substring(6));
              const content = data.choices[0]?.delta?.content || '';
              // 如果有内容，调用回调函数
              if (content) onChunk(content);
            } catch (e) {
              console.error('解析流数据失败', e);
            }
          } else if (line === 'data: [DONE]') {
            // 流结束标记
            break;
          }
        }
      }
      
      // 成功完成，返回
      return;
    } catch (error) {
      // 处理请求超时
      if (error.name === 'AbortError') {
        throw new Error('请求超时，请稍后重试');
      }
      
      // 处理重试逻辑
      retries++;
      if (retries > MAX_RETRIES) {
        console.error('流式API调用失败，已达到最大重试次数:', error);
        throw error;
      }
      
      // 指数退避重试
      console.log(`流式API调用失败，正在进行第${retries}次重试...`);
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, retries - 1)));
    }
  }
};

// 导出默认API服务
export default {
  sendMessage,
  streamMessage
}; 